package com.artisan.si.config;

import com.artisan.si.model.Order;
import com.artisan.si.model.User;
import com.artisan.si.service.OrderService;
import com.artisan.si.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.Filter;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.annotation.Transformer;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.messaging.MessageChannel;

/**
 * Spring Integration 配置类
 * 使用注解方式定义消息流处理管道：filter -> transform -> service activator
 */
@Configuration
public class IntegrationConfig {

    private static final Logger logger = LoggerFactory.getLogger(IntegrationConfig.class);
    
    // 注入服务
    private final OrderService orderService;
    private final UserService userService;
    
    public IntegrationConfig(OrderService orderService, UserService userService) {
        this.orderService = orderService;
        this.userService = userService;
    }

    /**
     * 输入通道（DirectChannel：同步传递，适合开发和示例）
     * @return 消息通道
     */
    @Bean("inputChannel")
    public MessageChannel inputChannel() {
        logger.info("创建输入通道 inputChannel");
        return new DirectChannel();
    }

    /**
     * 丢弃通道（用于处理被过滤器丢弃的消息）
     * @return 消息通道
     */
    @Bean("discardChannel") 
    public MessageChannel discardChannel() {
        logger.info("创建丢弃通道 discardChannel");
        return new DirectChannel();
    }

    /**
     * 过滤器：只允许数量 > 0 的订单通过
     * @param order 订单
     * @return 是否通过过滤
     */
    @Filter(inputChannel = "inputChannel", outputChannel = "transformChannel", discardChannel = "discardChannel")
    public boolean orderFilter(Order order) {
        boolean isValid = order != null && order.getQuantity() > 0;
        logger.debug("Filter: 订单 '{}' 验证结果: {}", 
                    order != null ? order.getProduct() : "null", isValid);
        return isValid;
    }

    /**
     * 转换通道
     * @return 消息通道
     */
    @Bean("transformChannel")
    public MessageChannel transformChannel() {
        return new DirectChannel();
    }

    /**
     * 转换器：清理和标准化订单数据
     * @param order 订单
     * @return 转换后的订单
     */
    @Transformer(inputChannel = "transformChannel", outputChannel = "serviceChannel")
    public Order orderTransformer(Order order) {
        if (order != null && order.getProduct() != null) {
            // 清理产品名称（去除前后空格）
            String cleanProduct = order.getProduct().trim();
            order.setProduct(cleanProduct);
            logger.debug("Transformer: 清理产品名称 -> '{}'", cleanProduct);
        }
        return order;
    }

    /**
     * 服务通道
     * @return 消息通道
     */
    @Bean("serviceChannel")
    public MessageChannel serviceChannel() {
        return new DirectChannel();
    }

    /**
     * 服务激活器：调用业务服务处理订单
     * @param order 订单（消息负载）
     */
    @ServiceActivator(inputChannel = "serviceChannel")
    public void orderServiceActivator(Order order) {
        logger.debug("ServiceActivator: 处理订单 {}", order);
        Order savedOrder = orderService.handleOrder(order);
        logger.info("ServiceActivator: 订单处理完成，ID={}", savedOrder.getId());
    }

    /**
     * 丢弃通道的处理器
     * @param order 被丢弃的订单
     */
    @ServiceActivator(inputChannel = "discardChannel")
    public void discardHandler(Order order) {
        logger.warn("订单被丢弃: product='{}', quantity={} (原因：数量 <= 0)", 
                   order != null ? order.getProduct() : "null", 
                   order != null ? order.getQuantity() : 0);
    }

    // ========================================
    // 用户注册业务流程（新增的独立通道）
    // ========================================

    /**
     * 用户注册输入通道
     * @return 用户消息通道
     */
    @Bean("userInputChannel")
    public MessageChannel userInputChannel() {
        logger.info("创建用户注册输入通道 userInputChannel");
        return new DirectChannel();
    }

    /**
     * 用户注册丢弃通道
     * @return 用户丢弃通道
     */
    @Bean("userDiscardChannel") 
    public MessageChannel userDiscardChannel() {
        logger.info("创建用户注册丢弃通道 userDiscardChannel");
        return new DirectChannel();
    }

    /**
     * 用户邮箱验证过滤器：只允许有效邮箱格式的用户通过
     * @param user 用户
     * @return 是否通过过滤
     */
    @Filter(inputChannel = "userInputChannel", outputChannel = "userTransformChannel", discardChannel = "userDiscardChannel")
    public boolean userEmailValidationFilter(User user) {
        boolean isValid = userService.validateUser(user);
        logger.debug("UserFilter: 用户 '{}' 验证结果: {}", 
                    user != null ? user.getEmail() : "null", isValid);
        return isValid;
    }

    /**
     * 用户转换通道
     * @return 用户转换通道
     */
    @Bean("userTransformChannel")
    public MessageChannel userTransformChannel() {
        return new DirectChannel();
    }

    /**
     * 用户数据转换器：标准化用户数据
     * @param user 用户
     * @return 转换后的用户
     */
    @Transformer(inputChannel = "userTransformChannel", outputChannel = "userServiceChannel")
    public User userDataTransformer(User user) {
        if (user != null) {
            // 标准化邮箱（转小写，去空格）
            if (user.getEmail() != null) {
                user.setEmail(user.getEmail().toLowerCase().trim());
            }
            // 标准化用户名（去空格）
            if (user.getUsername() != null) {
                user.setUsername(user.getUsername().trim());
            }
            // 标准化全名（去前后空格）
            if (user.getFullName() != null) {
                user.setFullName(user.getFullName().trim());
            }
            logger.debug("UserTransformer: 标准化用户数据 -> email='{}', username='{}'", 
                        user.getEmail(), user.getUsername());
        }
        return user;
    }

    /**
     * 用户服务通道
     * @return 用户服务通道
     */
    @Bean("userServiceChannel")
    public MessageChannel userServiceChannel() {
        return new DirectChannel();
    }

    /**
     * 用户服务激活器：调用业务服务处理用户注册
     * @param user 用户（消息负载）
     */
    @ServiceActivator(inputChannel = "userServiceChannel")
    public void userServiceActivator(User user) {
        logger.debug("UserServiceActivator: 处理用户注册 {}", user);
        try {
            User savedUser = userService.handleUserRegistration(user);
            logger.info("UserServiceActivator: 用户注册完成，ID={}, Email={}", 
                       savedUser.getId(), savedUser.getEmail());
        } catch (Exception e) {
            logger.error("UserServiceActivator: 用户注册失败 - {}", e.getMessage());
            throw e; // 重新抛出异常，让错误处理机制处理
        }
    }

    /**
     * 用户丢弃通道的处理器
     * @param user 被丢弃的用户
     */
    @ServiceActivator(inputChannel = "userDiscardChannel")
    public void userDiscardHandler(User user) {
        logger.warn("用户注册被拒绝: email='{}', username='{}' (原因：数据验证失败)", 
                   user != null ? user.getEmail() : "null", 
                   user != null ? user.getUsername() : "null");
    }
}